/*******************************************************************************
* Copyright (c) 2004, 2015 Richard Hoefter and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Richard Hoefter (richard.hoefter@web.de) - initial API and implementation, bug 95300, bug 95297, bug 128104, bug 201180, bug 288830
* IBM Corporation - NLS'ing and incorporating into Eclipse.
* - Bug 177833 Class created from combination of all utility classes of contribution
* - Bug 267459 Java project with an external jar file from C:\ on the build path throws a NPE during the Ant Buildfile generation.
* - bug fixing
*******************************************************************************/
package org.eclipse.ant.internal.ui.datatransfer;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.StringWriter;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.eclipse.ant.internal.core.IAntCoreConstants;
import org.eclipse.ant.internal.ui.AntUIPlugin;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModelMarker;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.junit.JUnitCore;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Shell;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
/**
* Collection of utility methods to help when exporting to an Ant build file.
*/
public class ExportUtil {
private ExportUtil() {
}
/**
* Get resource from selection.
*/
public static IResource getResource(ISelection selection) {
if (selection instanceof IStructuredSelection) {
for (Iterator<IAdaptable> iter = ((IStructuredSelection) selection).iterator(); iter.hasNext();) {
IAdaptable adaptable = iter.next();
return adaptable.getAdapter(IResource.class);
}
}
return null;
}
/**
* Get Java project from resource.
*/
public static IJavaProject getJavaProjectByName(String name) {
try {
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
if (project.exists()) {
return JavaCore.create(project);
}
}
catch (IllegalArgumentException iae) {
// do nothing
}
return null;
}
/**
* Get project root for given project.
*/
public static String getProjectRoot(IJavaProject project) {
if (project == null) {
return null;
}
IResource resource = project.getResource();
if (resource == null) {
return null;
}
IPath location = resource.getLocation();
if (location == null) {
return null;
}
return location.toString();
}
/**
* Convert Eclipse path to absolute filename.
*
* @param file
* Project root optionally followed by resource name. An absolute path is simply converted to a string.
* @return full qualified path
*/
public static String resolve(IPath file) {
if (file == null) {
return null;
}
try {
IFile f = ResourcesPlugin.getWorkspace().getRoot().getFile(file);
URI uri = f.getLocationURI();
return (uri != null) ? uri.toString() : f.toString();
}
catch (IllegalArgumentException e) {
// resource is missing
String projectName = removePrefix(file.toString(), "/"); //$NON-NLS-1$
IJavaProject project = getJavaProjectByName(projectName);
if (project != null) {
return getProjectRoot(project);
}
// project is null because file is not enclosed in a project i.e.
// external jar
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=267459
return file.toOSString();
}
}
/**
* Get Java project for given root.
*/
public static IJavaProject getJavaProject(String root) {
IPath path = new Path(root);
if (path.segmentCount() == 1) {
return getJavaProjectByName(root);
}
IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(path);
if (resource != null && resource.getType() == IResource.PROJECT) {
if (resource.exists()) {
return (IJavaProject) JavaCore.create(resource);
}
}
return null;
}
/**
* Remove project root from given project file.
*/
public static String removeProjectRoot(String file, IProject project) {
String res = removePrefix(file, '/' + project.getName() + '/');
if (res.equals('/' + project.getName())) {
return "."; //$NON-NLS-1$
}
return res;
}
/**
* Remove project root from given project file.
*
* @param newProjectRoot
* replace project root, e.g. with a variable ${project.location}
*/
public static String replaceProjectRoot(String file, IProject project, String newProjectRoot) {
String res = removeProjectRoot(file, project);
if (res.equals(".")) //$NON-NLS-1$
{
return newProjectRoot;
}
if (newProjectRoot == null) {
return res;
}
if (!res.equals(file)) {
return newProjectRoot + '/' + res;
}
return res;
}
/**
* Get for given project all directly dependent projects.
*
* @return set of IJavaProject objects
*/
public static List<IJavaProject> getClasspathProjects(IJavaProject project) throws JavaModelException {
List<IJavaProject> projects = new ArrayList<>();
IClasspathEntry entries[] = project.getRawClasspath();
addClasspathProjects(projects, entries);
return sortProjectsUsingBuildOrder(projects);
}
private static void addClasspathProjects(List<IJavaProject> projects, IClasspathEntry[] entries) {
for (int i = 0; i < entries.length; i++) {
IClasspathEntry classpathEntry = entries[i];
if (classpathEntry.getContentKind() == IPackageFragmentRoot.K_SOURCE && classpathEntry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
// found required project on build path
String subProjectRoot = classpathEntry.getPath().toString();
IJavaProject subProject = getJavaProject(subProjectRoot);
// is project available in workspace
if (subProject != null) {
projects.add(subProject);
}
}
}
}
/**
* Get for given project all directly and indirectly dependent projects.
*
* @return set of IJavaProject objects
*/
public static List<IJavaProject> getClasspathProjectsRecursive(IJavaProject project) throws JavaModelException {
LinkedList<IJavaProject> result = new LinkedList<>();
getClasspathProjectsRecursive(project, result);
return sortProjectsUsingBuildOrder(result);
}
private static void getClasspathProjectsRecursive(IJavaProject project, LinkedList<IJavaProject> result) throws JavaModelException {
List<IJavaProject> projects = getClasspathProjects(project);
for (Iterator<IJavaProject> iter = projects.iterator(); iter.hasNext();) {
IJavaProject javaProject = iter.next();
if (!result.contains(javaProject)) {
result.addFirst(javaProject);
getClasspathProjectsRecursive(javaProject, result); // recursion
}
}
}
/**
* Sort projects according to General -> Workspace -> Build Order.
*
* @param projects
* list of IJavaProject objects
* @return list of IJavaProject objects with new order
*/
private static List<IJavaProject> sortProjectsUsingBuildOrder(List<IJavaProject> javaProjects) {
if (javaProjects.isEmpty()) {
return javaProjects;
}
List<IJavaProject> result = new ArrayList<>(javaProjects.size());
IWorkspace workspace = ResourcesPlugin.getWorkspace();
String[] buildOrder = workspace.getDescription().getBuildOrder();
if (buildOrder == null) {// default build order
IProject[] projects = new IProject[javaProjects.size()];
int i = 0;
for (Iterator<IJavaProject> iter = javaProjects.iterator(); iter.hasNext(); i++) {
IJavaProject javaProject = iter.next();
projects[i] = javaProject.getProject();
}
IWorkspace.ProjectOrder po = ResourcesPlugin.getWorkspace().computeProjectOrder(projects);
projects = po.projects;
buildOrder = new String[projects.length];
for (i = 0; i < projects.length; i++) {
buildOrder[i] = projects[i].getName();
}
}
for (int i = 0; i < buildOrder.length && !javaProjects.isEmpty(); i++) {
String projectName = buildOrder[i];
for (Iterator<IJavaProject> iter = javaProjects.iterator(); iter.hasNext();) {
IJavaProject javaProject = iter.next();
if (javaProject.getProject().getName().equals(projectName)) {
result.add(javaProject);
iter.remove();
}
}
}
// add any remaining projects not specified in the build order
result.addAll(javaProjects);
return result;
}
/**
* Returns cyclic dependency marker for a given project.
*
* <p>
* See org.eclipse.jdt.core.tests.model.ClasspathTests.numberOfCycleMarkers.
*
* @param javaProject
* project for which cyclic dependency marker should be found
* @return cyclic dependency marker for a given project or <code>null</code> if there is no such marker
* @throws CoreException
*/
public static IMarker getCyclicDependencyMarker(IJavaProject javaProject) throws CoreException {
IMarker[] markers = javaProject.getProject().findMarkers(IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ONE);
for (int i = 0; i < markers.length; i++) {
IMarker marker = markers[i];
String cycleAttr = (String) marker.getAttribute(IJavaModelMarker.CYCLE_DETECTED);
if (cycleAttr != null && cycleAttr.equals("true")) //$NON-NLS-1$
{
return marker;
}
}
return null;
}
/**
* Find JUnit tests. Same tests are also returned by Eclipse run configuration wizard.
*
* @param containerHandle
* project, package or source folder
*/
public static IType[] findTestsInContainer(String containerHandle) {
IJavaElement container = JavaCore.create(containerHandle);
if (container == null) {
return new IType[0];
}
try {
return JUnitCore.findTestTypes(container, new NullProgressMonitor());
}
catch (OperationCanceledException e) {
AntUIPlugin.log(e);
}
catch (CoreException e) {
AntUIPlugin.log(e);
}
return new IType[0];
}
/**
* Compares projects by project name.
*/
public static synchronized Comparator<IJavaProject> getJavaProjectComparator() {
if (javaProjectComparator == null) {
javaProjectComparator = new JavaProjectComparator();
}
return javaProjectComparator;
}
private static Comparator<IJavaProject> javaProjectComparator;
private static class JavaProjectComparator implements Comparator<IJavaProject> {
@Override
public int compare(IJavaProject o1, IJavaProject o2) {
IJavaProject j1 = o1;
IJavaProject j2 = o2;
return j1.getProject().getName().compareTo(j2.getProject().getName());
}
}
/**
* Compares IFile objects.
*/
public static synchronized Comparator<IFile> getIFileComparator() {
if (fileComparator == null) {
fileComparator = new IFileComparator();
}
return fileComparator;
}
private static Comparator<IFile> fileComparator;
private static class IFileComparator implements Comparator<IFile> {
@Override
public int compare(IFile o1, IFile o2) {
IFile f1 = o1;
IFile f2 = o2;
return f1.toString().compareTo(f2.toString());
}
}
/**
* Compares IType objects.
*/
public static synchronized Comparator<IType> getITypeComparator() {
if (typeComparator == null) {
typeComparator = new TypeComparator();
}
return typeComparator;
}
private static Comparator<IType> typeComparator;
private static class TypeComparator implements Comparator<IType> {
@Override
public int compare(IType o1, IType o2) {
IType t1 = o1;
IType t2 = o2;
return t1.getFullyQualifiedName().compareTo(t2.getFullyQualifiedName());
}
}
/**
* Platform specific newline character(s).
*/
public static final String NEWLINE = System.getProperty("line.separator"); //$NON-NLS-1$
public static String removePrefix(String s, String prefix) {
if (s == null) {
return null;
}
if (s.startsWith(prefix)) {
return s.substring(prefix.length());
}
return s;
}
/**
* Remove suffix from given string.
*/
public static String removeSuffix(String s, String suffix) {
if (s == null) {
return null;
}
if (s.endsWith(suffix)) {
return s.substring(0, s.length() - suffix.length());
}
return s;
}
/**
* Remove prefix and suffix from given string.
*/
public static String removePrefixAndSuffix(String s, String prefix, String suffix) {
return removePrefix(removeSuffix(s, suffix), prefix);
}
/**
* Convert document to formatted XML string.
*/
public static String toString(Document doc) throws TransformerConfigurationException, TransformerFactoryConfigurationError, TransformerException {
// NOTE: There are different transformer implementations in the wild,
// which are configured differently
// regarding the indent size:
// Java 1.4: org.apache.xalan.transformer.TransformerIdentityImpl
// Java 1.5:
// com.sun.org.apache.xalan.internal.xsltc.trax.TransformerImpl
StringWriter writer = new StringWriter();
Source source = new DOMSource(doc);
Result result = new StreamResult(writer);
TransformerFactory factory = TransformerFactory.newInstance();
boolean indentFallback = false;
try {
// indent using TransformerImpl
factory.setAttribute("indent-number", "4"); //$NON-NLS-1$ //$NON-NLS-2$
}
catch (IllegalArgumentException e) {
// option not supported, set indent size below
indentFallback = true;
}
Transformer transformer = factory.newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
if (indentFallback) {
// indent using TransformerIdentityImpl
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); //$NON-NLS-1$ //$NON-NLS-2$
}
transformer.transform(source, result);
return writer.toString();
}
/**
* Read XML file.
*/
public static Document parseXmlFile(File file) throws SAXException, IOException, ParserConfigurationException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
Document doc = factory.newDocumentBuilder().parse(file);
return doc;
}
/**
* Read XML string.
*/
public static Document parseXmlString(String s) throws SAXException, IOException, ParserConfigurationException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
Document doc = factory.newDocumentBuilder().parse(new ByteArrayInputStream(s.getBytes()));
return doc;
}
/**
* Converts collection to a separated string.
*
* @param c
* collection
* @param separator
* string to separate items
* @return collection items separated with given separator
*/
public static String toString(Collection<String> c, String separator) {
StringBuffer b = new StringBuffer();
for (Iterator<String> iter = c.iterator(); iter.hasNext();) {
b.append(iter.next());
b.append(separator);
}
if (c.size() > 0) {
b.delete(b.length() - separator.length(), b.length());
}
return b.toString();
}
/**
* Remove duplicates preserving original order.
*
* @param l
* list to remove duplicates from
* @return new list without duplicates
*/
public static List<String> removeDuplicates(List<String> l) {
List<String> res = new ArrayList<>();
for (Iterator<String> iter = l.iterator(); iter.hasNext();) {
String element = iter.next();
if (!res.contains(element)) {
res.add(element);
}
}
return res;
}
/**
* Check if given file exists that was not written by this export.
*/
public static boolean existsUserFile(String filename) {
File buildFile = new File(filename);
if (buildFile.exists()) {
try (BufferedReader in = new BufferedReader(new FileReader(buildFile))) {
int i = BuildFileCreator.WARNING.indexOf(NEWLINE);
String warning = BuildFileCreator.WARNING.substring(0, i);
String line;
while ((line = in.readLine()) != null) {
if (line.indexOf(warning) != -1) {
return false;
}
}
return true;
}
catch (FileNotFoundException e) {
return false;
}
catch (IOException e) {
return false;
}
}
return false;
}
/**
* Request write access to given file. Depending on the version control plug-in opens a confirm checkout dialog.
*
* @param shell
* parent instance for dialogs
* @param file
* file to request write access for
* @return <code>true</code> if user confirmed checkout
*/
public static boolean validateEdit(Shell shell, IFile file) {
return file.getWorkspace().validateEdit(new IFile[] { file }, shell).isOK();
}
/**
* Request write access to given files. Depending on the version control plug-in opens a confirm checkout dialog.
*
* @param shell
* parent instance for dialogs
* @return <code>IFile</code> objects for which user confirmed checkout
* @throws CoreException
* thrown if project is under version control, but not connected
*/
public static Set<IFile> validateEdit(Shell shell, List<IFile> files) throws CoreException {
Set<IFile> confirmedFiles = new TreeSet<>(getIFileComparator());
if (files.size() == 0) {
return confirmedFiles;
}
IStatus status = files.get(0).getWorkspace().validateEdit(files.toArray(new IFile[files.size()]), shell);
if (status.isMultiStatus() && status.getChildren().length > 0) {
for (int i = 0; i < status.getChildren().length; i++) {
IStatus statusChild = status.getChildren()[i];
if (statusChild.isOK()) {
confirmedFiles.add(files.get(i));
}
}
} else if (status.isOK()) {
for (Iterator<IFile> iterator = files.iterator(); iterator.hasNext();) {
IFile file = iterator.next();
confirmedFiles.add(file);
}
}
if (status.getSeverity() == IStatus.ERROR) {
// not possible to checkout files: not connected to version
// control plugin or hijacked files and made read-only, so
// collect error messages provided by validator and re-throw
StringBuffer message = new StringBuffer(status.getPlugin() + ": " //$NON-NLS-1$
+ status.getMessage() + NEWLINE);
if (status.isMultiStatus()) {
for (int i = 0; i < status.getChildren().length; i++) {
IStatus statusChild = status.getChildren()[i];
message.append(statusChild.getMessage() + NEWLINE);
}
}
throw new CoreException(new Status(IStatus.ERROR, AntUIPlugin.PI_ANTUI, 0, message.toString(), null));
}
return confirmedFiles;
}
/**
* Check if given classpath is a reference to the default classpath of the project. Ideal for testing if runtime classpath was customized.
*/
public static boolean isDefaultClasspath(IJavaProject project, EclipseClasspath classpath) {
// default classpath contains exactly the JRE and the project reference
List<String> list = removeDuplicates(classpath.rawClassPathEntries);
if (list.size() != 2) {
return false;
}
String entry1 = list.get(0);
String entry2 = list.get(1);
if (!EclipseClasspath.isJreReference(entry1)) {
return false;
}
if (EclipseClasspath.isProjectReference(entry2)) {
IJavaProject referencedProject = EclipseClasspath.resolveProjectReference(entry2);
if (referencedProject == null) {
// project was not loaded in workspace
return false;
} else if (referencedProject.getProject().getName().equals(project.getProject().getName())) {
return true;
}
}
return false;
}
/**
* Add variable/value for Eclipse variable. If given string is no variable, nothing is added.
*
* @param variable2valueMap
* property map to add variable/value
* @param s
* String which may contain Eclipse variables, e.g. ${project_name}
*/
public static void addVariable(Map<String, String> variable2valueMap, String s, String projectRoot) {
if (s == null || s.equals(IAntCoreConstants.EMPTY_STRING)) {
return;
}
Pattern pattern = Pattern.compile("\\$\\{.*?\\}"); // ${var} //$NON-NLS-1$
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
String variable = matcher.group();
String value;
try {
value = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(variable);
}
catch (CoreException e) {
// cannot resolve variable
value = variable;
}
variable = removePrefixAndSuffix(variable, "${", "}"); //$NON-NLS-1$ //$NON-NLS-2$
// if it is an environment variable, convert to Ant environment
// syntax
if (variable.startsWith("env_var:")) //$NON-NLS-1$
{
value = "env." + variable.substring("env_var:".length()); //$NON-NLS-1$ //$NON-NLS-2$
}
File file = new File(value);
if (file.exists()) {
value = getRelativePath(file.getAbsolutePath(), projectRoot);
}
variable2valueMap.put(variable, value);
}
}
/**
* Returns a path which is equivalent to the given location relative to the specified base path.
*/
public static String getRelativePath(String otherLocation, String basePath) {
IPath location = new Path(otherLocation);
IPath base = new Path(basePath);
if ((location.getDevice() != null && !location.getDevice().equalsIgnoreCase(base.getDevice())) || !location.isAbsolute()) {
return otherLocation;
}
int baseCount = base.segmentCount();
int count = base.matchingFirstSegments(location);
String temp = IAntCoreConstants.EMPTY_STRING;
for (int j = 0; j < baseCount - count; j++) {
temp += "../"; //$NON-NLS-1$
}
String relative = new Path(temp).append(location.removeFirstSegments(count)).toString();
if (relative.length() == 0) {
relative = "."; //$NON-NLS-1$
}
return relative;
}
}